[Home] Python으로 돌아가기

함수와 메서드 - def, return, 변수, 인자, dir, help, 내포함수

[참조]

 

📖 목차

(1) 내장함수(built-in function)

(2) 함수와 메서드의 정의: def

(3) 매개변수와 인자

(4) 함수값 return

(5) mutable(변경 가능) 인자 vs immutable(변경 불가능) 인자

(6) opt를 사용한 default와 option 인자의 지정

(7) 인자의 개수가 정해지지 않을 때 *arg와 **kwargs

(8) 함수 내 함수

(9) 사용자 정의 함수로 저장한 파일을 import로 불러오기

(10) 내포함수(內包함수; 內for함수;comprehension function)

 

(1) 내장 함수 (Built-in Function)

파이썬에는 기본적으로 포함되어 바로 사용할 수 있는 다양한 내장 함수가 존재한다. 이러한 함수들은 수치 계산, 자료형 변환, 자료 구조 탐색 및 제어 등에 널리 사용되며, 프로그램의 간결성과 효율성을 높여준다.

아래는 자주 사용되는 일부 내장 함수와 그 사용 예이다.

(2) 함수와 메서드의 정의: def

1) 함수(Function)와 메서드(Method)의 차이

프로그래밍 언어에서 함수와 메서드는 모두 특정 작업을 수행하기 위한 코드 블록을 의미하지만, 사용되는 문맥과 호출 방식에서 차이가 존재한다.

구분 함수 (Function) 메서드 (Method)
정의 위치 클래스 외부 또는 독립적으로 정의됨 클래스 내부에 정의되어 객체를 통해 호출됨
호출 방법 함수이름(인자) 객체.메서드이름(인자)
self 사용 여부 사용하지 않음 첫 번째 인자로 self를 사용함
예시 코드 def add(a, b): return a + b class Calc:
 def add(self, b):
  return self.a + b
대표 예 len([1, 2, 3]) (내장 함수) "text".upper() (문자열 메서드)

즉, 함수는 독립적으로 사용할 수 있는 반면, 메서드는 객체와 함께 사용하는 객체 지향적 함수라고 할 수 있다.

파이썬에서 함수는 def 키워드를 사용하여 정의한다. 함수는 특정 작업을 수행하는 명령문 집합으로, 코드의 재사용성과 구조화를 돕는다.

2) 함수 정의의 기본 구조


def 함수이름(매개변수1, 매개변수2, ...):
    실행할 코드
    return 반환값

(예시 1) 두 수를 더하는 함수


def add(a, b):
    return a + b

result = add(3, 5)
print(result)  # 출력: 8

(예시 2) 반환값 없이 단순 출력


def greet(name):
    print(f"{name}님, 반갑습니다!")

greet("민수")  # 출력: 민수님, 반갑습니다!

(예시 3) 인자가 없는 함수


def print_logo():
    print("=== My Program ===")

print_logo()

(3) 매개변수와 인자

함수 정의와 호출 시 사용되는 값과 변수는 다음과 같이 구분된다.

구분 역할 예시 코드 예시 이름
파라미터 함수 정의에 사용됨 def f(x): x (파라미터)
인자 함수 호출에 전달됨 f(10) 10 (인자)

(예시)


def add_text(t1, t2="파이썬"):
    print(t1 + " : " + t2)

add_text("hello", "python")  # t1="hello", t2="python"
add_text("hi")               # t1="hi", t2="파이썬" (기본값 사용)

이 예시에서 t1, t2는 매개변수이며, 함수 호출 시 전달된 "hello", "python"은 인자이다. t2는 기본값을 가지므로 두 번째 인자를 생략할 수 있다.

(정리)

• 매개변수는 함수 정의부에서 선언
• 인자는 함수 호출부에서 전달
• 기본값이 있는 매개변수는 선택적으로 전달 가능

(4) 함수값 return

함수는 실행 결과를 반환하기 위해 return 문을 사용한다. 반환값은 하나일 수도 있고, 여러 개일 경우 튜플 형태로 반환된다. 함수는 return 문을 만나면 즉시 실행을 종료하고, 해당 값을 호출한 위치로 전달한다. 


def add(a, b):
    return a + b

result = add(3, 5)  # result는 8이 된다.

여러 개의 값을 반환하고자 할 경우, 쉼표로 구분하여 작성하면 튜플로 반환된다. 


def calculate(a, b):
    sum_ = a + b
    diff = a - b
    return sum_, diff

x, y = calculate(10, 3)
print(x)  # 13
print(y)  # 7

(5) mutable(변경 가능) vs immutable(변경 불가능) 인자

파이썬에서는 객체의 변경 가능 여부에 따라 자료형이 mutable과 immutable로 구분된다.

함수 호출 시 mutable 객체를 인자로 전달하면, 함수 내부에서 해당 객체를 변경할 수 있으며, 그 변경 사항은 호출한 쪽에도 영향을 미친다. 


def modify_list(lst):
    lst.append(100)

numbers = [1, 2, 3]
modify_list(numbers)
print(numbers)  # [1, 2, 3, 100]

반면, immutable 객체는 함수 내에서 값을 변경하더라도 원본에는 영향을 주지 않는다. 


def modify_value(x):
    x += 10

a = 5
modify_value(a)
print(a)  # 5 (변경되지 않음)

(6) 기본값(default) 및 선택적(optional) 인자 지정

함수를 정의할 때 인자에 기본값을 지정하면, 호출 시 해당 인자를 생략할 수 있다. 이러한 인자는 선택적 인자(optional parameter)라고도 하며, 함수의 유연성을 높여준다. 


def greet(name, message="안녕하세요"):
    print(f"{message}, {name}님!")

greet("민수")                # 안녕하세요, 민수님!
greet("지영", "환영합니다")  # 환영합니다, 지영님!

기본값이 지정된 인자는 반드시 기본값이 없는 인자 뒤에 와야 한다. 


# 올바른 예
def func(a, b=0): pass

# 잘못된 예 (SyntaxError 발생)
def func(a=0, b): pass

복잡한 수식에서 optional 인자는 함수 내부에서 조건문을 사용해 분기처리를 할 수 있다. 


def compute(value, method='exact'):
    if method == 'exact':
        return value ** 2
    else:
        return round(value ** 2, 1)

(7) 인자의 개수가 정해지지 않을 때 *args와 **kwargs

함수를 정의할 때 전달되는 인자의 개수가 고정되어 있지 않은 경우, 파이썬에서는 *args와 **kwargs를 사용하여 가변적인 개수의 인자를 받을 수 있다.

📌 *args – 위치 인자(Non-keyword arguments)

*args는 함수에 전달되는 인자를 **튜플(tuple)** 형태로 받아들이며, 개수에 제한이 없다. 함수 내부에서는 일반적인 반복문을 통해 개별 인자에 접근할 수 있다. 


def add(*args):
    result = 0
    for num in args:
        result += num
    return result

add(1, 2, 3)  # 결과: 6

📌 **kwargs – 키워드 인자(Keyword arguments)

**kwargs는 키워드 형태로 전달되는 인자들을 **딕셔너리(dictionary)** 형태로 받아들인다. 함수 내부에서는 키(key)와 값(value) 쌍으로 인자를 처리할 수 있다. 


def print_info(**kwargs):
    for key, value in kwargs.items():
        print(f"{key} = {value}")

print_info(name="Alice", age=30, job="Engineer")

(출력)


name = Alice
age = 30
job = Engineer

📌 *args와 **kwargs의 혼용

함수 정의 시 *args와 **kwargs는 함께 사용할 수 있으며, 반드시 *args가 먼저, **kwargs가 뒤에 와야 한다. 


def mixed_example(fixed, *args, **kwargs):
    print(f"기본 인자: {fixed}")
    print(f"가변 인자: {args}")
    print(f"키워드 인자: {kwargs}")

mixed_example("기본값", 1, 2, 3, lang="Python", level="Intermediate")

(출력)


기본 인자: 기본값
가변 인자: (1, 2, 3)
키워드 인자: {'lang': 'Python', 'level': 'Intermediate'}

(요약)

• *args는 위치 기반 인자를 튜플로 받음
• **kwargs는 키워드 기반 인자를 딕셔너리로 받음
• 두 개를 함께 사용할 경우, 순서에 유의할 것: 일반 인자 → *args → **kwargs

(8) 함수 내 함수 (Nested Function)

파이썬에서는 하나의 함수 내부에 또 다른 함수를 정의할 수 있다. 이를 중첩 함수(nested function) 또는 내부 함수(inner function)라고 하며, 외부 함수의 일부 로직을 내부적으로 캡슐화하거나, 클로저(closure) 구조를 구현할 때 자주 사용된다.

내부 함수는 자신을 포함하고 있는 외부 함수의 변수에 접근할 수 있으며, 외부에서는 호출할 수 없다. 이러한 특징을 통해 **함수 내의 일시적인 계산**, **정보 은닉**, **코드 구조화** 등의 효과를 얻을 수 있다.

(예제)


def outer_function():
    outer_list = [1, 2]
    
    def inner_function():
        outer_list.append(3)
    
    inner_function()
    print(outer_list)

outer_function()

(출력 결과)


[1, 2, 3]

(설명)

• inner_function()은 outer_function() 내부에 정의되어, 외부 함수가 실행될 때만 호출 가능하다.
• 내부 함수는 외부 함수의 변수 outer_list에 접근할 수 있으며, 그 값을 변경할 수도 있다.
• 외부 함수의 실행이 종료되면 내부 함수는 소멸한다.

이와 같이 중첩 함수는 임시적인 처리 또는 특정 조건 하에서만 유효한 로직을 정의할 때 유용하게 사용된다. 또한 데코레이터(decorator)와 같은 고급 기능의 구현에서도 핵심적인 역할을 수행한다.

(9) 사용자 정의 함수로 저장한 파일을 import로 불러오기

사용자가 직접 정의한 함수를 하나의 파이썬 파일(.py)로 저장해 두고, 이후 다른 파이썬 파일에서 import 문을 통해 해당 함수를 불러올 수 있다. 이러한 방식은 코드의 재사용성과 모듈화를 가능하게 하며, 협업 및 대규모 프로젝트 구성에도 효과적이다.

1) 함수 정의 파일 예시 (예: my_module.py)


# 파일명: my_module.py

def add(a, b):
    return a + b

def multiply(a, b):
    return a * b

2) import를 통한 함수 불러오기

다른 파이썬 파일 또는 인터프리터 환경에서 import 또는 from ... import ... 구문을 통해 함수를 사용할 수 있다. 


# 전체 모듈 불러오기
import my_module

result = my_module.add(3, 4)

# 특정 함수만 불러오기
from my_module import multiply

result = multiply(5, 2)

3) 모듈의 위치

모듈 파일은 같은 디렉토리에 있거나, PYTHONPATH 환경 변수 또는 sys.path에 등록된 경로 내에 존재해야 import가 가능하다. 


import sys
print(sys.path)  # 모듈 검색 경로 확인

4) 별칭(alias) 사용


import my_module as mm

print(mm.add(1, 2))  # 별칭으로 함수 호출 가능

이와 같이 사용자 정의 함수 파일을 외부에서 모듈로 불러와 사용할 수 있으며, 복잡한 코드 구조를 기능별로 나누어 관리할 수 있다.

(10) 내포함수(內包함수; 內for함수;comprehension function)

파이썬의 내포(comprehension) 함수는 컬렉션 자료형(리스트, 튜플, 집합, 딕셔너리 등)을 보다 간결하고 직관적인 문법으로 생성할 수 있도록 하는 표현식이다. 기존의 반복문과 조건문을 한 줄로 표현함으로써 코드의 가독성을 높이며, 간단한 자료 구조를 선언할 때 유용하게 활용된다.

내포 함수를 활용하면 반복문과 조건문을 간결하게 표현할 수 있으며, 동일한 결과를 더 적은 코드로 구현할 수 있다. 특히 리스트나 딕셔너리 생성 시 자주 사용된다.

내포 함수는 주로 리스트 내포(list comprehension), 딕셔너리 내포(dictionary comprehension), 집합 내포(set comprehension), 제너레이터 표현식(generator expression)으로 구분된다.

1) 리스트 내포 (List Comprehension)


# 기존 방식
result = []
for i in range(10):
    if i % 2 == 0:
        result.append(i)


# 표현식
[expression for item in iterable if condition]


# 리스트 내포 방식
result = [i for i in range(10) if i % 2 == 0]

2) 딕셔너리 내포 (Dictionary Comprehension)


# 기존 방식
squares = {}
for i in range(5):
    if i % 2 == 1:
        squares[i] = i * i


# 표현식
{key_expr: value_expr for item in iterable if condition}


# 딕셔너리 내포 방식
squares = {i: i * i for i in range(5) if i % 2 == 1}

3) 집합 내포 (Set Comprehension)


# 기존 방식
unique_lengths = set()
words = ["apple", "banana", "cherry"]
for word in words:
    if len(word) > 5:
        unique_lengths.add(len(word))


# 표현식
{expression for item in iterable if condition}


# 집합 내포 방식
unique_lengths = {len(word) for word in ["apple", "banana", "cherry"] if len(word) > 5}

4) 제너레이터 표현식 (Generator Expression)

튜플 내포는 명시적으로 존재하지 않지만, 제너레이터 표현식을 사용하여 유사한 동작을 수행할 수 있다. 


# 기존 방식
def square_gen():
    for i in range(5):
        if i % 2 == 0:
            yield i * i

gen = square_gen()


# 표현식
(expression for item in iterable if condition)


# 제너레이터 표현식
gen = (i * i for i in range(5) if i % 2 == 0)

💡 구성 요소 설명

• expression   : 반복 대상 요소에 대한 계산식 또는 처리식
• item         : 순회 대상(iterable)의 각 요소를 나타내는 변수
• iterable     : 반복 가능한 객체 (리스트, 튜플, 집합 등)
• condition    : 선택적으로 작성하는 필터 조건. 조건이 참일 경우에만 결과가 포함됨